import javafx.scene.control.Alert;

import java.util.Arrays;

public class Tset4{
    public static void main(String[] args) {
        int[] arr = new int[]{1, 4, 5};
        // ArrayToString1(arr);
        //ArrayToString2(arr);
        //System.out.print(chaz1(arr,9));
        /*adjustOrder1(arr);
        System.out.print(Arrays.toString((arr)));*/


    }
    //数组转字符串
    //方法1 使用Array.toString这个库方法
    public static void ArrayToString1(int[] array) {
        //定义一个String类型接收字符串，使用Array.toString把array转为字符串
        String ArrayToString = Arrays.toString(array);
        System.out.println(ArrayToString);//输出
    }

    //方法2 模拟实现字符串打印过程
    public static void ArrayToString2(int[] array) {
        //先打印[
        System.out.print("[");
        //遍历
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);//输出所有元素
            //判断是否要继续打印空格和逗号
            if (array[i] < array.length) {
                System.out.print(" " + ",");
            }
        }
        System.out.print("]");//最后打印 ]
    }

    //求数组中元素的平均值
    //方法1
    public static double AverageCalculator1(int[] array) {
        double sum = 0;
        //遍历
        for (int i = 0; i < array.length; i++) {
            //求和
            sum = sum + array[i];
        }
        //返回平均值
        return sum / array.length;
    }

    //方法2
    public static double AverageCalculator2(int[] array) {
        //使用Stream API 求平均值
        double average = Arrays.stream(array).average().orElse(0.0);
        return average;//返回
    }

    //查找数组中指定元素(顺序查找)
    public static int chaz1(int[] array, int a) {
        //遍历
        for (int i = 0; i < array.length; i++) {
            //判断是否相等
            if (array[i] == a) {

                return array[i];
            }
        }
        return -1;//不存在元素
    }

    //查找数组中指定元素(二分查找)
    public static int chaz2(int[] array, int a) {
        //先排序，确定数组有序
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
        //查找指定元素
        int l = 0;
        int r = array.length - 1;
        while (l <= r) {
            int m = (l + r) / 2;
            if (array[m] == a) {
                return array[m];
            } else if (array[m] > a) {
                r = m - 1;
            } else if (array[m] < a) {
                l = m + 1;
            }

        }
        return -1;
    }

    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
    public static int[] transform(int[] array) {

        for (int i = 0; i < array.length; i++) {

            array[i] = array[i] * 2;
        }
        return array;
    }

    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序
    public static void adjustOrder1(int[] array) {
        int l = 0;//L为0
        int r = array.length - 1;//最后一个下标
        //循环条件
        while (l < r) {
            //奇数&1 = 1 偶数&1 = 0
            if ((array[l] & 1) == 0 && (array[r] & 1) == 1) {
                int tmp = array[l];//交换
                array[l] = array[r];
                array[r] = tmp;
                //奇数就自增
            } else if ((array[l] & 1) == 1) {
                l++;
                //偶数自减
            } else if ((array[r] & 1) == 0) {
                r--;
            }
        }
    }

    //方法二创建两个数组分别存奇数和偶数
    public static void adjustOrder2(int[] array) {
        int[] temp = new int[array.length]; // 创建一个临时数组
        int oddIndex = 0; // 用于记录奇数在临时数组中的位置
        int evenIndex = array.length - 1; // 用于记录偶数在临时数组中的位置

        // 遍历原数组
        for (int num : array) {
            if (num % 2 != 0) {
                // 如果是奇数，放在临时数组的前面
                temp[oddIndex++] = num;
            } else {
                // 如果是偶数，放在临时数组的后面
                temp[evenIndex--] = num;
            }
        }
        // 将临时数组的内容复制回原数组
        System.arraycopy(temp, 0, array, 0, array.length);
    }

    //给定一个整型数组, 实现冒泡排序(升序排序)
    public void bubbleSort(int[] array) {

        //外层循环控制需要多少躺
        for (int i = 0; i < array.length - 1; i++) {
            boolean boo = false;//测试数组是否有序
            //内存循环控制一趟的排序
            for (int j = 0; j < array.length - 1 - i; j++) {
                //前一个数比后一个数大交换数值
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = array[j];
                    boo = true;//执行了说明数组发生了交换，数组还是无序状态
                }
            }
            if (boo == false) {//没有交换就直接跳出循环
                break;
            }
        }
    }
    public int[] chaz(int[] arr,int a) {
        for (int i = 0; i < arr.length; i++) {

            for (int j = 0; j < arr.length; j++) {

                if(a == arr[i] + arr[j]){
                    return new int[]{i,j};
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}
